/* Copyright (C) 2014 InfiniDB, Inc.

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; version 2 of
   the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
   MA 02110-1301, USA. */

/*******************************************************************************
* $Id$
*
*******************************************************************************/

/*
 * we_brmrprtparser.cpp
 *
 *  Created on: Dec 13, 2011
 *      Author: bpaul
 */

#include <fstream>
#include <iostream>
using namespace std;

#include "we_brmrprtparser.h"

namespace WriteEngine
{

BrmReportParser::BrmReportParser():fRptFile()
{

}

BrmReportParser::~BrmReportParser()
{

}

//------------------------------------------------------------------------------
// Serialize specified RptFileName into the ByteStream Bs.
// Serialization is done one record at a time.  File should be an ASCII file
// with newlines markers, because getline() is used.
// Function is limited to records that are no longer than 255 bytes.
// If a record is longer than 255 bytes, the function misbehaves.
//------------------------------------------------------------------------------
bool BrmReportParser::serialize(std::string RptFileName,
									messageqcpp::ByteStream& Bs)
{
	try
	{
	fRptFile.open(RptFileName.c_str(), ifstream::in);
	}
	catch(std::exception& ex)
	{
		cout <<"Failed to open BRMRptFile "<< RptFileName <<endl;
		cout << ex.what() << endl;
		throw runtime_error(ex.what());
	}
	if(fRptFile.good())
	{
		char aBuff[10240];
		unsigned int aLen=0;
		while(fRptFile.good() && !fRptFile.eof())
		{
			fRptFile.getline(aBuff, sizeof(aBuff)-1);
			aLen=fRptFile.gcount();
			if((aLen != (sizeof(aBuff)-1)) && (aLen>0))
			{
				//aBuff[aLen-1] = '\n';
				//aBuff[aLen]=0;
				//cout << "Data Read " << aBuff <<endl;
				if(aBuff[0] != '#')	// do not serialize comments
				{
					std::string strData = aBuff;
					Bs << strData;
				}
			}
		}// while
		fRptFile.close();
		cout << "Closed File : "<< RptFileName <<" "<< errno << endl;
	}
	else
	{
		cout << "Failed to open : "<< RptFileName <<" "<< errno << endl;
		return false;
	}
	return true;
}

//------------------------------------------------------------------------------
// Serialize specified RptFileName into the ByteStream Bs.
// Serialization is done in 8192 byte blocks instead of by line or by record,
// so that this function will work for both character and binary files.
//------------------------------------------------------------------------------
bool BrmReportParser::serializeBlocks(std::string RptFileName,
	messageqcpp::ByteStream& Bs)
{
	try
	{
		fRptFile.open(RptFileName.c_str(), ifstream::in);
	}
	catch (std::exception& ex)
	{
		cout <<"Failed to open Report File "<< RptFileName << endl;
		cout << ex.what() << endl;
		return false;
	}

	if (fRptFile.good())
	{
		char aBuff[8192];
		unsigned int aLen=0;
		std::string strBuff;

		while ( fRptFile.good() )
		{
			fRptFile.read(aBuff, sizeof(aBuff));
			aLen = fRptFile.gcount();

			if (aLen > 0)
			{
				strBuff.assign( aBuff, aLen );
				Bs << strBuff;
			}
		}

		fRptFile.close();
		cout << "Closed Report File : "<< RptFileName << endl;
	}
	else
	{
        std::ostringstream oss;
		oss << "Failed to open Report File " << RptFileName << endl;
		cout << oss.str() << endl;
		return false;
	}

	return true;
}

void BrmReportParser::unserialize(messageqcpp::ByteStream& Bs)
{
	//TODO to be changed. left it here to understand how to implement
	/*
	ObjectReader::checkType(b, ObjectReader::SIMPLECOLUMN);
	ReturnedColumn::unserialize(b); // parent class unserialize
	b >> (uint32_t&) fOid;
	b >> fData;
	b >> reinterpret_cast<ByteStream::doublebyte&>(fReturnAll);
	b >> (uint32_t&) fSequence;
	*/

	std::string aStrLine;
	while(Bs.length()>0)
	{
		Bs >> aStrLine;
		cout << aStrLine;
	}

}





} /* namespace WriteEngine */
